//文本
export class 文本 {
    static 取文本长度(文本) {
        return 文本 ? 文本.length : 0;
    }

    static 取文本行数(文本) {
        if (!文本) return 0;
        return 文本.split('\n').length;
    }

    static 寻找文本(文本, 子文本, 起始位置 = 0) {
        if (!文本 || !子文本) return -1;
        return 文本.indexOf(子文本, 起始位置);
    }

    static 倒找文本(文本, 子文本, 起始位置) {
        if (!文本 || !子文本) return -1;
        return 文本.lastIndexOf(子文本, 起始位置);
    }

    static 取文本中间(文本, 起始, 长度) {
        if (!文本 || 起始 == null) return "";
        return 文本.substr(起始, 长度);
    }

    static 取文本左边(文本, 长度) {
        if (!文本) return "";
        if (isNaN(长度) || 长度 == null || 长度 < 0 || 长度 > 文本.length) 长度 = 文本.length;
        return 文本.substr(0, 长度);
    }

    static 取文本右边(文本, 长度) {
        if (!文本) return "";
        if (isNaN(长度) || 长度 == null || 长度 < 0 || 长度 > 文本.length) 长度 = 文本.length;
        return 文本.substring(文本.length - 长度);
    }

    static 取指定文本(待取文本, 左边文本, 右边文本) {
        const 正则 = new RegExp(左边文本 + "(.*?)" + 右边文本, "g");
        const 结果 = [];
        let 匹配;
        while ((匹配 = 正则.exec(待取文本)) !== null) {
            结果.push(匹配[1]);
        }
        return 结果;
    }

    static 子文本替换(文本, 原子文本, 新子文本) {
        if (!文本 || !原子文本 || 新子文本 == null) return "";
        const 正则 = new RegExp(原子文本, "g");
        return 文本.replace(正则, 新子文本);
    }

    static 分割文本(文本, 分隔符) {
        if (!文本 || 分隔符 == null) return null;
        return 文本.split(分隔符);
    }

    static 到大写(文本) {
        return 文本 ? 文本.toUpperCase() : "";
    }

    static 到小写(文本) {
        return 文本 ? 文本.toLowerCase() : "";
    }

    static 删首尾空(文本) {
        return 文本 ? 文本.trim() : "";
    }

    static 删全部空(文本) {
        return 文本 ? 文本.replace(/\s+/g, "") : "";
    }
    static 是否包含(文本, 子文本) {
        return 文本 && 子文本 ? 文本.includes(子文本) : false;
    }
    static 是否以某开头(文本, 开头文本) {
        return 文本 && 开头文本 ? 文本.startsWith(开头文本) : false;
    }
    static 是否以某结尾(文本, 结尾文本) {
        return 文本 && 结尾文本 ? 文本.endsWith(结尾文本) : false;
    }
    static 去除指定字符(文本, 字符) {
        return 文本 ? 文本.replace(new RegExp(字符, "g"), "") : "";
    }
}

//数组
export class 数组 {
    static 取成员数(数组) {
        return 数组 ? 数组.length : 0;
    }

    static 合并数组(数组1, 数组2) {
        if (!数组1) return 数组2;
        if (!数组2) return 数组1;
        return 数组1.concat(数组2);
    }

    static 连接成员(数组, 分隔符) {
        if (!数组 || 分隔符 == null) return "";
        return 数组.join(分隔符);
    }

    static 加入首成员(数组, 成员) {
        if (!数组) return 0;
        数组.unshift(成员);
        return 数组.length;
    }

    static 加入尾成员(数组, 成员) {
        if (!数组) return 0;
        数组.push(成员);
        return 数组.length;
    }

    static 删除首成员(数组) {
        if (!数组) return 0;
        数组.shift();
        return 数组.length;
    }

    static 删除尾成员(数组) {
        if (!数组) return 0;
        数组.pop();
        return 数组.length;
    }

    static 删除成员(数组, 索引) {
        if (!数组) return 0;
        数组.splice(索引, 1);
        return 数组.length;
    }

    static 清空数组(数组) {
        if (!数组) return 0;
        数组.splice(0, 数组.length);
        return 数组.length;
    }

    static 翻转顺序(数组) {
        if (数组) 数组.reverse();
    }

    static 排列顺序(数组, 类型 = 1) {
        if (!数组) return;
        if (类型 === 1) {
            数组.sort();
        } else {
            数组.sort((甲, 乙) => 甲 - 乙);
        }
    }
    static 查找成员(数组, 成员) {
        return 数组 ? 数组.indexOf(成员) : -1;
    }
    static 去重(数组) {
        return 数组 ? Array.from(new Set(数组)) : [];
    }
    static 过滤成员(数组, 条件函数) {
        return 数组 ? 数组.filter(条件函数) : [];
    }
    static 映射成员(数组, 映射函数) {
        return 数组 ? 数组.map(映射函数) : [];
    }
}

//转换
export class 转换 {
    static 到文本(值) {
        return String(值);
    }

    static 到数值(文本) {
        return Number(文本);
    }

    static 到十六进制(值) {
        return Number(值).toString(16);
    }

    static 到十进制(文本) {
        return parseInt(文本, 16);
    }

    static 代码转字符(...代码) {
        return String.fromCharCode(...代码);
    }

    static 字符转代码(文本) {
        return 文本.charCodeAt(0);
    }

    static 文本转json(文本) {
        return JSON.parse(文本);
    }

    static json转文本(json对象) {
        return JSON.stringify(json对象);
    }

    static 取数据类型(值) {
        const 类型 = typeof 值;
        switch (类型) {
            case "number": return 1;
            case "string": return 2;
            case "boolean": return 3;
            case "object": return 4;
            case "function": return 5;
            case "undefined": return 6;
            default: return 6;
        }
    }

    static 是否为非数字(值) {
        return isNaN(值);
    }

    static 转换为金额(金额) {
        const 小数单位 = ["角", "分"];
        const 数字汉字 = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
        const 单位 = [["元", "万", "亿"], ["", "拾", "佰", "仟"]];
        const 头 = 金额 < 0 ? "欠" : "";
        let n = Math.abs(金额);
        let s = "";
        for (let i = 0; i < 小数单位.length; i++) {
            s += (数字汉字[Math.floor(n * 10 * Math.pow(10, i)) % 10] + 小数单位[i]).replace(/零./, "");
        }
        s = s || "整";
        n = Math.floor(n);
        for (let i = 0; i < 单位[0].length && n > 0; i++) {
            let p = "";
            for (let j = 0; j < 单位[1].length && n > 0; j++) {
                p = 数字汉字[n % 10] + 单位[1][j] + p;
                n = Math.floor(n / 10);
            }
            s = p.replace(/(零.)*零$/, "").replace(/^$/, "零") + 单位[0][i] + s;
        }
        return 头 + s.replace(/(零.)*零元/, "元").replace(/(零.)+/g, "零").replace(/^整$/, "零元整");
    }
    static 到布尔值(值) {
        return Boolean(值);
    }
    static 日期格式化(日期, 格式 = "yyyy-MM-dd") {
        if (!日期) return "";
        const y = 日期.getFullYear();
        const m = String(日期.getMonth() + 1).padStart(2, "0");
        const d = String(日期.getDate()).padStart(2, "0");
        return 格式.replace("yyyy", y).replace("MM", m).replace("dd", d);
    }
}

//数学
export class 数学 {
    static 取随机数(最小值, 最大值) {
        return Math.floor(Math.random() * (最大值 - 最小值 + 1) + 最小值);
    }

    static 取绝对值(值) {
        return Math.abs(值);
    }

    static 取余数(被除数, 除数) {
        return 被除数 % 除数;
    }

    static 取整数(值) {
        return parseInt(值);
    }

    static 取次方(底数, 指数) {
        return Math.pow(底数, 指数);
    }

    static 四舍五入(值, 小数位数) {
        return Math.round(值 * Math.pow(10, 小数位数)) / Math.pow(10, 小数位数);
    }

    static 表达式计算(表达式文本) {
        return eval(表达式文本);
    }
    static 取最大值(...值) {
        return Math.max(...值);
    }
    static 取最小值(...值) {
        return Math.min(...值);
    }
    static 取平均值(数组) {
        return 数组 && 数组.length ? 数组.reduce((a, b) => a + b, 0) / 数组.length : 0;
    }
}

//时间日期
export class 时间 {
    static 取当前日期时间() {
        return new Date();
    }

    static 取现行日期() {
        const 日期 = new Date();
        const 月 = String(日期.getMonth() + 1).padStart(2, "0");
        const 日 = String(日期.getDate()).padStart(2, "0");
        return `${日期.getFullYear()}/${月}/${日}`;
    }

    static 取现行时间() {
        const 日期 = new Date();
        const 时 = String(日期.getHours()).padStart(2, "0");
        const 分 = String(日期.getMinutes()).padStart(2, "0");
        const 秒 = String(日期.getSeconds()).padStart(2, "0");
        return `${时}:${分}:${秒}`;
    }

    static 到日期时间(年, 月, 日, 时, 分, 秒) {
        return new Date(年, 月 - 1, 日, 时, 分, 秒);
    }

    static 到日期时间2(文本) {
        return new Date(文本);
    }

    static 时间到文本(日期) {
        const 月 = String(日期.getMonth() + 1).padStart(2, "0");
        const 日 = String(日期.getDate()).padStart(2, "0");
        const 时 = String(日期.getHours()).padStart(2, "0");
        const 分 = String(日期.getMinutes()).padStart(2, "0");
        const 秒 = String(日期.getSeconds()).padStart(2, "0");
        return `${日期.getFullYear()}/${月}/${日} ${时}:${分}:${秒}`;
    }

    static 取时间间隔(时间1, 时间2) {
        return 时间1.getTime() - 时间2.getTime();
    }

    static 取年(时间) {
        return 时间.getFullYear();
    }

    static 取月(时间) {
        return 时间.getMonth() + 1;
    }

    static 取日(时间) {
        return 时间.getDate();
    }

    static 取时(时间) {
        return 时间.getHours();
    }

    static 取分(时间) {
        return 时间.getMinutes();
    }

    static 取秒(时间) {
        return 时间.getSeconds();
    }

    static 取星期几(时间) {
        return 时间.getDay();
    }

    static 取时间戳(时间) {
        return Date.parse(时间);
    }

    static 时间戳到时间(时间戳) {
        return new Date(时间戳);
    }
    static 日期加减(日期, 天数) {
        const 新日期 = new Date(日期);
        新日期.setDate(新日期.getDate() + 天数);
        return 新日期;
    }
}

//正则
export class 正则 {
    constructor() {
        this.结果 = null;
        this.数量 = 0;
        this.数组 = null;
        this.标志 = "";
        this.表达式 = "";
    }
    static 创建正则(所有文本, 正则文本, 不区分大小写, 多行查找) {
        this.标志 = "g";
        if (不区分大小写) this.标志 += "i";
        if (多行查找) this.标志 += "m";
        this.表达式 = 正则文本;
        this.结果 = 所有文本.match(new RegExp(正则文本, this.标志));
    }
    static 取匹配数量() {
        return this.结果 ? this.结果.length : 0;
    }
    static 取匹配文本(索引) {
        if (!this.结果) return "";
        return 索引 == null ? this.结果 : this.结果[索引];
    }
    static 取子匹配文本(匹配索引, 子匹配索引) {
        if (!this.结果) return "";
        this.数组 = this.结果[匹配索引].match(new RegExp(this.表达式, this.标志.replace("g", "")));
        return this.数组 ? this.数组[子匹配索引] : "";
    }
    static 是否匹配(文本, 正则文本) {
        return new RegExp(正则文本).test(文本);
    }
    static 替换文本(文本, 正则文本, 新文本) {
        return 文本.replace(new RegExp(正则文本, "g"), 新文本);
    }
}

//定时器
export class 定时器 {
    static 延时调用(回调, 延时, ...参数) {
        return setTimeout(回调, 延时, ...参数);
    }
    static 结束延时调用(定时器ID) {
        clearTimeout(定时器ID);
    }
    static 时钟(回调, 间隔, ...参数) {
        return setInterval(回调, 间隔, ...参数);
    }
    static 结束时钟(时钟ID) {
        clearInterval(时钟ID);
    }
    static 倒计时(秒数, 回调, 完成回调) {
        let 剩余 = 秒数;
        const 定时器ID = setInterval(() => {
            剩余--;
            回调 && 回调(剩余);
            if (剩余 <= 0) {
                clearInterval(定时器ID);
                完成回调 && 完成回调();
            }
        }, 1000);
        return 定时器ID;
    }
}